package com.ca.ridersclubapplication.data;

import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;

import com.ca.ridersclubapplication.data.entity.BooleanEntity;
import com.ca.ridersclubapplication.data.entity.Handleable;
import com.ca.ridersclubapplication.data.entity.ListEntity;
import com.ca.ridersclubapplication.data.entity.LongEntity;
import com.ca.ridersclubapplication.data.entity.StringEntity;
import com.ca.ridersclubapplication.data.entity.Token;
import com.ca.ridersclubapplication.request.dto.LoginResult;
import com.ca.ridersclubapplication.view.CallbackView;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 数据处理器，存储网络请求的数据，也可以取出这些数据
 * 当数据更新时，同时会更新对应视图控件
 */
public class DataHandler {

    /**
     * 用于存放用户认证信息
     */
    private static SharedPreferences sp;
    private static final Token token = new Token();

    /**
     * 用于存放网络中数据
     */
    private static final Map<String, Handleable> handleableMap = new HashMap<>();

    /**
     * 用于存放待更新的视图控件
     */
    private static final Map<String, List<CallbackView>> viewMap = new HashMap<>();

    /**
     * 存放数据，会覆盖原先的数据
     */
    public static synchronized void putData(Handleable handleable) {

        if (handleable == null) {
            return;
        }

        //  将数据放入map中
        handleableMap.put(handleable.getKey(), handleable);

        //  如果数据为ListEntity类型，则遍历整个，放入map中
        if (handleable instanceof ListEntity) {
            ListEntity<? extends Handleable> listEntity = (ListEntity<? extends Handleable>) handleable;
            for (Handleable h : listEntity.getList()) {
                putData(h);
            }
        }

        //  更新key对应的视图控件
        List<CallbackView> viewList = viewMap.get(handleable.getKey());
        if (viewList == null) {
            return;
        }
        for (CallbackView view : viewList) {
            view.update();
        }
    }

    /**
     * 增加数值型数据
     */
    public static synchronized void incData(LongEntity handleable) {

        if (handleable == null) {
            return;
        }

        //  取出数据
        Handleable data = getData(handleable.getKey());
        if (data instanceof LongEntity) {
            Long value = ((LongEntity) data).getValue();
            value += handleable.getValue();
            //  存入增加后的数据
            handleableMap.put(handleable.getKey(), new LongEntity(handleable.getKey(), value));
        }
        else {
            //  存入传入的数据
            handleableMap.put(handleable.getKey(), handleable);
        }

        //  更新key对应的视图控件
        List<CallbackView> viewList = viewMap.get(handleable.getKey());
        if (viewList == null) {
            return;
        }
        for (CallbackView view : viewList) {
            view.update();
        }
    }

    /**
     * 追加列表类型的数据，不会覆盖原有的数据
     * 如果原列表中已包含同样的数据，则不会添加到数据处理器中
     */
    public static synchronized void appendListData(ListEntity<? extends Handleable> listEntity) {

        //  取出原有列表数据
        Handleable handleable = handleableMap.get(listEntity.getKey());

        //  如果原数据的类型为数据列表类型，则进行追加
        if (handleable instanceof ListEntity<?>) {
            List<? extends Handleable> dataList = ((ListEntity<?>) handleable).getList();

            List<Handleable> tempList = new ArrayList<>(dataList);
            for (Handleable h : listEntity.getList()) {
                //  遍历传入的数据列表，如果原列表中不包含该数据则追加到数据处理器中
                if (!tempList.contains(h)) {
                    tempList.add(h);
                }
            }

            //  将tempList（原有数据 + 新数据）覆盖原有数据列表
            putData(new ListEntity<>(listEntity.getKey(), tempList));
        }
        else {
            //  原数据类型不是数据列表类型，则覆盖原有数据
            putData(listEntity);
        }
    }

    public static synchronized void appendStringData(String key, String value) {

        //  查询数据
        Handleable data = DataHandler.getData(key);
        if (data instanceof ListEntity) {
            ListEntity<?> list = (ListEntity<?>) data;
            List<StringEntity> temp = new ArrayList<>();
            for (Handleable h : list.getList()) {
                if (h instanceof StringEntity) {
                    String v = ((StringEntity) h).getValue();
                    temp.add(new StringEntity(h.getKey(), v));
                }
            }
            temp.add(new StringEntity(key, value));

            //  存入增加过的数据
            handleableMap.put(key, new ListEntity<>(key, temp));
        }
        else {
            //  直接存入
            List<StringEntity> list = new ArrayList<>();
            list.add(new StringEntity(key, value));
            ListEntity<StringEntity> le = new ListEntity<>(key, list);
            handleableMap.put(key, le);
        }

        //  更新key对应的视图控件
        List<CallbackView> viewList = viewMap.get(key);
        if (viewList == null) {
            return;
        }
        for (CallbackView view : viewList) {
            view.update();
        }
    }

    /**
     * 获取数据
     */
    public static Handleable getData(String key) {
        return handleableMap.get(key);
    }

    public static synchronized void deleteData(String key) {
        //  移除数据
        handleableMap.remove(key);

        //  移除对应的视图列表
        List<CallbackView> viewList = viewMap.get(key);
        if (viewList == null) {
            return;
        }
        viewMap.remove(key);
    }

    /**
     * 放入视图控件
     */
    public static void putView(String key, CallbackView view) {
        List<CallbackView> viewLis = viewMap.get(key);
        if (viewLis == null) {
            viewLis = new ArrayList<>();
            viewMap.put(key, viewLis);
        }
        viewLis.add(view);
    }

    /**
     * 移除视图控件
     */
    public static synchronized void removeView(String key, CallbackView view) {
        List<CallbackView> viewList = viewMap.get(key);
        if (viewList == null) {
            return;
        }
        viewList.remove(view);
    }

    /**
     * 获取登录用户的Token
     */
    public static Token getToken(Activity activity) {
        initSP(activity);
        token.setId(sp.getLong("id", 0));
        token.setEmail(sp.getString("email", ""));
        token.setToken(sp.getString("token", ""));
        return token;
    }

    /**
     * 用户是否登录
     */
    public static boolean isLogin(Activity activity) {
        initSP(activity);
        return sp.getBoolean("isLogin", false);
    }

    /**
     * 登录，记录用户认证信息
     */
    public static synchronized void login(Activity activity, LoginResult loginResult) {

        if (loginResult == null) {
            logout(activity);
            return;
        }

        initSP(activity);
        token.setId(loginResult.getId());
        token.setEmail(loginResult.getEmail());
        token.setToken(loginResult.getToken());
        sp.edit().putLong("id", token.getId())
                .putString("email", token.getEmail())
                .putString("token", token.getToken())
                .putBoolean("isLogin", true)
                .apply();

        //  存放因登录状态改变而更新的视图数据
        putData(new BooleanEntity("Login", true));
    }

    /**
     * 退出登录
     */
    public static synchronized void logout(Activity activity) {

        //  存放因登录状态改变而更新的视图数据
        putData(new BooleanEntity("Login", false));

        //  清空用户认证信息
        initSP(activity);
        token.setId(0L);
        token.setEmail("");
        token.setToken("");
        sp.edit().remove("id")
                .remove("email")
                .remove("token")
                .remove("isLogin").apply();

        //  停止所有Activity

        //  停止所有的服务

        //  启动首页Activity
    }

    private static void initSP(Activity activity) {
        if (sp == null) {
            sp = activity.getSharedPreferences("auth", Context.MODE_PRIVATE);
        }
    }
}
